// $ANTLR 3.1 C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g 2008-10-15 07:23:01

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

public class gramaticaMM2Lexer extends Lexer {
    public static final int LIST_ARGS=77;
    public static final int WHILE=14;
    public static final int MOD=29;
    public static final int LETTER=102;
    public static final int BODY_RETURN=64;
    public static final int CASE=12;
    public static final int CHAR=22;
    public static final int DO=19;
    public static final int ASPA=49;
    public static final int NOT=24;
    public static final int EOF=-1;
    public static final int ASSIGN_COMMAND_ID=65;
    public static final int PEREN_EXP=99;
    public static final int CASE_COMMAND=71;
    public static final int GREATER=32;
    public static final int BEGIN=5;
    public static final int TERM_EXPRESSION=85;
    public static final int RIGHT_BRACKET=46;
    public static final int RETURN=16;
    public static final int WRITESTRING=53;
    public static final int WRITEINT=50;
    public static final int FOR_COMMAND=69;
    public static final int VAR=7;
    public static final int BODY=63;
    public static final int CLAUSE=81;
    public static final int WRITESTRING_COMMAND=76;
    public static final int ARRAY=23;
    public static final int FUNC_CALL_EXPRESSION=88;
    public static final int NEQUAL=31;
    public static final int TIPO=92;
    public static final int INT_POSITIVO=97;
    public static final int CARACTER=95;
    public static final int ELSE=11;
    public static final int BOOL=100;
    public static final int DECLAR=93;
    public static final int SEMICOLON=41;
    public static final int MULT=27;
    public static final int OF=8;
    public static final int WHILE_COMMAND=70;
    public static final int EQUAL_NEQUAL=83;
    public static final int WS=104;
    public static final int WRITELN=54;
    public static final int WRITEBOOL=52;
    public static final int LIST_NUMBER_RANGE=78;
    public static final int TIPO_ARRAY=98;
    public static final int INTEIRO=94;
    public static final int OR=37;
    public static final int LEFT_PAREN=43;
    public static final int CALL_COMMAND=67;
    public static final int LOWER=33;
    public static final int END=6;
    public static final int ARITMETIC_EXPRESSION=84;
    public static final int WRITECHAR=51;
    public static final int LOWER_EQUAL=35;
    public static final int LEFT_BRACKET=45;
    public static final int DECLAR_PROC=57;
    public static final int FOR=13;
    public static final int AND=36;
    public static final int ID=91;
    public static final int LIST_VAR_ARRAY=60;
    public static final int LIST_VAR_ID=59;
    public static final int ASSIGN_COMMAND_ID_ARRAY=66;
    public static final int IF=9;
    public static final int ID_EXPRESSION=89;
    public static final int RIGHT_PAREN=44;
    public static final int BOOLEAN=21;
    public static final int THEN=10;
    public static final int COMMA=39;
    public static final int EQUAL=30;
    public static final int WRITEBOOL_COMMAND=74;
    public static final int WRITELN_COMMAND=75;
    public static final int PLUS=26;
    public static final int DECLAR_FUNC=58;
    public static final int DIGIT=101;
    public static final int HEADER=56;
    public static final int DOT=42;
    public static final int MINUS_EXPRESSION=87;
    public static final int EXPRESSION=80;
    public static final int LIST_PARAM=62;
    public static final int INTEGER=20;
    public static final int BY=18;
    public static final int NOT_EXPRESSION=86;
    public static final int TO=17;
    public static final int LITERAL=82;
    public static final int MINUS=25;
    public static final int MODULE=4;
    public static final int PROCEDURE=15;
    public static final int DIGIT_NULL=47;
    public static final int WRITECHAR_COMMAND=73;
    public static final int COLON=40;
    public static final int NEWLINE=103;
    public static final int ASSIGN=38;
    public static final int PROGRAM=55;
    public static final int LIST_NUMBER=79;
    public static final int WRITEINT_COMMAND=72;
    public static final int ID_ARRAY=90;
    public static final int DIV=28;
    public static final int GREATER_EQUAL=34;
    public static final int DECLAR_VAR=61;
    public static final int BAR=48;
    public static final int STRING=96;
    public static final int IF_COMMAND=68;

    // delegates
    // delegators

    public gramaticaMM2Lexer() {;} 
    public gramaticaMM2Lexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public gramaticaMM2Lexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g"; }

    // $ANTLR start "MODULE"
    public final void mMODULE() throws RecognitionException {
        try {
            int _type = MODULE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:3:8: ( 'MODULE' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:3:10: 'MODULE'
            {
            match("MODULE"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MODULE"

    // $ANTLR start "BEGIN"
    public final void mBEGIN() throws RecognitionException {
        try {
            int _type = BEGIN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:4:7: ( 'BEGIN' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:4:9: 'BEGIN'
            {
            match("BEGIN"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BEGIN"

    // $ANTLR start "END"
    public final void mEND() throws RecognitionException {
        try {
            int _type = END;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:5:5: ( 'END' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:5:7: 'END'
            {
            match("END"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "END"

    // $ANTLR start "VAR"
    public final void mVAR() throws RecognitionException {
        try {
            int _type = VAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:6:5: ( 'VAR' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:6:7: 'VAR'
            {
            match("VAR"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "VAR"

    // $ANTLR start "OF"
    public final void mOF() throws RecognitionException {
        try {
            int _type = OF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:7:4: ( 'OF' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:7:6: 'OF'
            {
            match("OF"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OF"

    // $ANTLR start "IF"
    public final void mIF() throws RecognitionException {
        try {
            int _type = IF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:8:4: ( 'IF' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:8:6: 'IF'
            {
            match("IF"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IF"

    // $ANTLR start "THEN"
    public final void mTHEN() throws RecognitionException {
        try {
            int _type = THEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:9:6: ( 'THEN' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:9:8: 'THEN'
            {
            match("THEN"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "THEN"

    // $ANTLR start "ELSE"
    public final void mELSE() throws RecognitionException {
        try {
            int _type = ELSE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:10:6: ( 'ELSE' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:10:8: 'ELSE'
            {
            match("ELSE"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ELSE"

    // $ANTLR start "CASE"
    public final void mCASE() throws RecognitionException {
        try {
            int _type = CASE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:11:6: ( 'CASE' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:11:8: 'CASE'
            {
            match("CASE"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CASE"

    // $ANTLR start "FOR"
    public final void mFOR() throws RecognitionException {
        try {
            int _type = FOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:12:5: ( 'FOR' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:12:7: 'FOR'
            {
            match("FOR"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FOR"

    // $ANTLR start "WHILE"
    public final void mWHILE() throws RecognitionException {
        try {
            int _type = WHILE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:13:7: ( 'WHILE' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:13:9: 'WHILE'
            {
            match("WHILE"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WHILE"

    // $ANTLR start "PROCEDURE"
    public final void mPROCEDURE() throws RecognitionException {
        try {
            int _type = PROCEDURE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:14:11: ( 'PROCEDURE' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:14:13: 'PROCEDURE'
            {
            match("PROCEDURE"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PROCEDURE"

    // $ANTLR start "RETURN"
    public final void mRETURN() throws RecognitionException {
        try {
            int _type = RETURN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:15:8: ( 'RETURN' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:15:10: 'RETURN'
            {
            match("RETURN"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RETURN"

    // $ANTLR start "TO"
    public final void mTO() throws RecognitionException {
        try {
            int _type = TO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:16:4: ( 'TO' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:16:6: 'TO'
            {
            match("TO"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TO"

    // $ANTLR start "BY"
    public final void mBY() throws RecognitionException {
        try {
            int _type = BY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:17:4: ( 'BY' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:17:6: 'BY'
            {
            match("BY"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BY"

    // $ANTLR start "DO"
    public final void mDO() throws RecognitionException {
        try {
            int _type = DO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:18:4: ( 'DO' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:18:6: 'DO'
            {
            match("DO"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DO"

    // $ANTLR start "INTEGER"
    public final void mINTEGER() throws RecognitionException {
        try {
            int _type = INTEGER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:19:9: ( 'INTEGER' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:19:11: 'INTEGER'
            {
            match("INTEGER"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INTEGER"

    // $ANTLR start "BOOLEAN"
    public final void mBOOLEAN() throws RecognitionException {
        try {
            int _type = BOOLEAN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:20:9: ( 'BOOLEAN' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:20:11: 'BOOLEAN'
            {
            match("BOOLEAN"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BOOLEAN"

    // $ANTLR start "CHAR"
    public final void mCHAR() throws RecognitionException {
        try {
            int _type = CHAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:21:6: ( 'CHAR' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:21:8: 'CHAR'
            {
            match("CHAR"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CHAR"

    // $ANTLR start "ARRAY"
    public final void mARRAY() throws RecognitionException {
        try {
            int _type = ARRAY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:22:7: ( 'ARRAY' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:22:9: 'ARRAY'
            {
            match("ARRAY"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ARRAY"

    // $ANTLR start "NOT"
    public final void mNOT() throws RecognitionException {
        try {
            int _type = NOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:23:5: ( 'NOT' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:23:7: 'NOT'
            {
            match("NOT"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NOT"

    // $ANTLR start "MINUS"
    public final void mMINUS() throws RecognitionException {
        try {
            int _type = MINUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:24:7: ( '-' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:24:9: '-'
            {
            match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "PLUS"
    public final void mPLUS() throws RecognitionException {
        try {
            int _type = PLUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:25:6: ( '+' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:25:8: '+'
            {
            match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "MULT"
    public final void mMULT() throws RecognitionException {
        try {
            int _type = MULT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:26:6: ( '*' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:26:8: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MULT"

    // $ANTLR start "DIV"
    public final void mDIV() throws RecognitionException {
        try {
            int _type = DIV;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:27:5: ( 'DIV' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:27:7: 'DIV'
            {
            match("DIV"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DIV"

    // $ANTLR start "MOD"
    public final void mMOD() throws RecognitionException {
        try {
            int _type = MOD;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:28:5: ( 'MOD' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:28:7: 'MOD'
            {
            match("MOD"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MOD"

    // $ANTLR start "EQUAL"
    public final void mEQUAL() throws RecognitionException {
        try {
            int _type = EQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:29:7: ( '=' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:29:9: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EQUAL"

    // $ANTLR start "NEQUAL"
    public final void mNEQUAL() throws RecognitionException {
        try {
            int _type = NEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:30:8: ( '<>' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:30:10: '<>'
            {
            match("<>"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NEQUAL"

    // $ANTLR start "GREATER"
    public final void mGREATER() throws RecognitionException {
        try {
            int _type = GREATER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:31:9: ( '>' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:31:11: '>'
            {
            match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GREATER"

    // $ANTLR start "LOWER"
    public final void mLOWER() throws RecognitionException {
        try {
            int _type = LOWER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:32:7: ( '<' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:32:9: '<'
            {
            match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LOWER"

    // $ANTLR start "GREATER_EQUAL"
    public final void mGREATER_EQUAL() throws RecognitionException {
        try {
            int _type = GREATER_EQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:33:15: ( '>=' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:33:17: '>='
            {
            match(">="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GREATER_EQUAL"

    // $ANTLR start "LOWER_EQUAL"
    public final void mLOWER_EQUAL() throws RecognitionException {
        try {
            int _type = LOWER_EQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:34:13: ( '<=' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:34:15: '<='
            {
            match("<="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LOWER_EQUAL"

    // $ANTLR start "AND"
    public final void mAND() throws RecognitionException {
        try {
            int _type = AND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:35:5: ( 'AND' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:35:7: 'AND'
            {
            match("AND"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AND"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:36:4: ( 'OR' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:36:6: 'OR'
            {
            match("OR"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "ASSIGN"
    public final void mASSIGN() throws RecognitionException {
        try {
            int _type = ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:37:8: ( ':=' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:37:10: ':='
            {
            match(":="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ASSIGN"

    // $ANTLR start "COMMA"
    public final void mCOMMA() throws RecognitionException {
        try {
            int _type = COMMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:38:7: ( ',' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:38:9: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMMA"

    // $ANTLR start "COLON"
    public final void mCOLON() throws RecognitionException {
        try {
            int _type = COLON;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:39:7: ( ':' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:39:9: ':'
            {
            match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COLON"

    // $ANTLR start "SEMICOLON"
    public final void mSEMICOLON() throws RecognitionException {
        try {
            int _type = SEMICOLON;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:40:11: ( ';' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:40:13: ';'
            {
            match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SEMICOLON"

    // $ANTLR start "DOT"
    public final void mDOT() throws RecognitionException {
        try {
            int _type = DOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:41:5: ( '.' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:41:7: '.'
            {
            match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DOT"

    // $ANTLR start "LEFT_PAREN"
    public final void mLEFT_PAREN() throws RecognitionException {
        try {
            int _type = LEFT_PAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:42:12: ( '(' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:42:14: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LEFT_PAREN"

    // $ANTLR start "RIGHT_PAREN"
    public final void mRIGHT_PAREN() throws RecognitionException {
        try {
            int _type = RIGHT_PAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:43:13: ( ')' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:43:15: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RIGHT_PAREN"

    // $ANTLR start "LEFT_BRACKET"
    public final void mLEFT_BRACKET() throws RecognitionException {
        try {
            int _type = LEFT_BRACKET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:44:14: ( '[' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:44:16: '['
            {
            match('['); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LEFT_BRACKET"

    // $ANTLR start "RIGHT_BRACKET"
    public final void mRIGHT_BRACKET() throws RecognitionException {
        try {
            int _type = RIGHT_BRACKET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:45:15: ( ']' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:45:17: ']'
            {
            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RIGHT_BRACKET"

    // $ANTLR start "DIGIT_NULL"
    public final void mDIGIT_NULL() throws RecognitionException {
        try {
            int _type = DIGIT_NULL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:46:12: ( '0' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:46:14: '0'
            {
            match('0'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DIGIT_NULL"

    // $ANTLR start "BAR"
    public final void mBAR() throws RecognitionException {
        try {
            int _type = BAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:47:5: ( '|' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:47:7: '|'
            {
            match('|'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BAR"

    // $ANTLR start "ASPA"
    public final void mASPA() throws RecognitionException {
        try {
            int _type = ASPA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:48:6: ( '\\'' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:48:8: '\\''
            {
            match('\''); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ASPA"

    // $ANTLR start "WRITEINT"
    public final void mWRITEINT() throws RecognitionException {
        try {
            int _type = WRITEINT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:49:10: ( 'WRITEINT' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:49:12: 'WRITEINT'
            {
            match("WRITEINT"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WRITEINT"

    // $ANTLR start "WRITECHAR"
    public final void mWRITECHAR() throws RecognitionException {
        try {
            int _type = WRITECHAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:50:11: ( 'WRITECHAR' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:50:13: 'WRITECHAR'
            {
            match("WRITECHAR"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WRITECHAR"

    // $ANTLR start "WRITEBOOL"
    public final void mWRITEBOOL() throws RecognitionException {
        try {
            int _type = WRITEBOOL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:51:11: ( 'WRITEBOOL' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:51:13: 'WRITEBOOL'
            {
            match("WRITEBOOL"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WRITEBOOL"

    // $ANTLR start "WRITESTRING"
    public final void mWRITESTRING() throws RecognitionException {
        try {
            int _type = WRITESTRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:52:13: ( 'WRITESTRING' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:52:15: 'WRITESTRING'
            {
            match("WRITESTRING"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WRITESTRING"

    // $ANTLR start "WRITELN"
    public final void mWRITELN() throws RecognitionException {
        try {
            int _type = WRITELN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:53:9: ( 'WRITELN' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:53:11: 'WRITELN'
            {
            match("WRITELN"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WRITELN"

    // $ANTLR start "LETTER"
    public final void mLETTER() throws RecognitionException {
        try {
            int _type = LETTER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:190:9: ( 'a' .. 'z' | 'A' .. 'Z' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LETTER"

    // $ANTLR start "DIGIT"
    public final void mDIGIT() throws RecognitionException {
        try {
            int _type = DIGIT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:192:7: ( '1' .. '9' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:192:9: '1' .. '9'
            {
            matchRange('1','9'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DIGIT"

    // $ANTLR start "BOOL"
    public final void mBOOL() throws RecognitionException {
        try {
            int _type = BOOL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:194:6: ( 'TRUE' | 'FALSE' )
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0=='T') ) {
                alt1=1;
            }
            else if ( (LA1_0=='F') ) {
                alt1=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }
            switch (alt1) {
                case 1 :
                    // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:194:8: 'TRUE'
                    {
                    match("TRUE"); 


                    }
                    break;
                case 2 :
                    // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:194:15: 'FALSE'
                    {
                    match("FALSE"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BOOL"

    // $ANTLR start "NEWLINE"
    public final void mNEWLINE() throws RecognitionException {
        try {
            int _type = NEWLINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:196:9: ( ( '\\r' )? '\\n' )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:196:10: ( '\\r' )? '\\n'
            {
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:196:10: ( '\\r' )?
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0=='\r') ) {
                alt2=1;
            }
            switch (alt2) {
                case 1 :
                    // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:196:10: '\\r'
                    {
                    match('\r'); 

                    }
                    break;

            }

            match('\n'); 
            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NEWLINE"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:198:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:198:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
            {
            // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:198:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
            int cnt3=0;
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( ((LA3_0>='\t' && LA3_0<='\n')||LA3_0=='\r'||LA3_0==' ') ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:
            	    {
            	    if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt3 >= 1 ) break loop3;
                        EarlyExitException eee =
                            new EarlyExitException(3, input);
                        throw eee;
                }
                cnt3++;
            } while (true);

            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WS"

    public void mTokens() throws RecognitionException {
        // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:8: ( MODULE | BEGIN | END | VAR | OF | IF | THEN | ELSE | CASE | FOR | WHILE | PROCEDURE | RETURN | TO | BY | DO | INTEGER | BOOLEAN | CHAR | ARRAY | NOT | MINUS | PLUS | MULT | DIV | MOD | EQUAL | NEQUAL | GREATER | LOWER | GREATER_EQUAL | LOWER_EQUAL | AND | OR | ASSIGN | COMMA | COLON | SEMICOLON | DOT | LEFT_PAREN | RIGHT_PAREN | LEFT_BRACKET | RIGHT_BRACKET | DIGIT_NULL | BAR | ASPA | WRITEINT | WRITECHAR | WRITEBOOL | WRITESTRING | WRITELN | LETTER | DIGIT | BOOL | NEWLINE | WS )
        int alt4=56;
        alt4 = dfa4.predict(input);
        switch (alt4) {
            case 1 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:10: MODULE
                {
                mMODULE(); 

                }
                break;
            case 2 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:17: BEGIN
                {
                mBEGIN(); 

                }
                break;
            case 3 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:23: END
                {
                mEND(); 

                }
                break;
            case 4 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:27: VAR
                {
                mVAR(); 

                }
                break;
            case 5 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:31: OF
                {
                mOF(); 

                }
                break;
            case 6 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:34: IF
                {
                mIF(); 

                }
                break;
            case 7 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:37: THEN
                {
                mTHEN(); 

                }
                break;
            case 8 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:42: ELSE
                {
                mELSE(); 

                }
                break;
            case 9 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:47: CASE
                {
                mCASE(); 

                }
                break;
            case 10 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:52: FOR
                {
                mFOR(); 

                }
                break;
            case 11 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:56: WHILE
                {
                mWHILE(); 

                }
                break;
            case 12 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:62: PROCEDURE
                {
                mPROCEDURE(); 

                }
                break;
            case 13 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:72: RETURN
                {
                mRETURN(); 

                }
                break;
            case 14 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:79: TO
                {
                mTO(); 

                }
                break;
            case 15 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:82: BY
                {
                mBY(); 

                }
                break;
            case 16 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:85: DO
                {
                mDO(); 

                }
                break;
            case 17 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:88: INTEGER
                {
                mINTEGER(); 

                }
                break;
            case 18 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:96: BOOLEAN
                {
                mBOOLEAN(); 

                }
                break;
            case 19 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:104: CHAR
                {
                mCHAR(); 

                }
                break;
            case 20 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:109: ARRAY
                {
                mARRAY(); 

                }
                break;
            case 21 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:115: NOT
                {
                mNOT(); 

                }
                break;
            case 22 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:119: MINUS
                {
                mMINUS(); 

                }
                break;
            case 23 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:125: PLUS
                {
                mPLUS(); 

                }
                break;
            case 24 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:130: MULT
                {
                mMULT(); 

                }
                break;
            case 25 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:135: DIV
                {
                mDIV(); 

                }
                break;
            case 26 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:139: MOD
                {
                mMOD(); 

                }
                break;
            case 27 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:143: EQUAL
                {
                mEQUAL(); 

                }
                break;
            case 28 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:149: NEQUAL
                {
                mNEQUAL(); 

                }
                break;
            case 29 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:156: GREATER
                {
                mGREATER(); 

                }
                break;
            case 30 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:164: LOWER
                {
                mLOWER(); 

                }
                break;
            case 31 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:170: GREATER_EQUAL
                {
                mGREATER_EQUAL(); 

                }
                break;
            case 32 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:184: LOWER_EQUAL
                {
                mLOWER_EQUAL(); 

                }
                break;
            case 33 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:196: AND
                {
                mAND(); 

                }
                break;
            case 34 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:200: OR
                {
                mOR(); 

                }
                break;
            case 35 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:203: ASSIGN
                {
                mASSIGN(); 

                }
                break;
            case 36 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:210: COMMA
                {
                mCOMMA(); 

                }
                break;
            case 37 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:216: COLON
                {
                mCOLON(); 

                }
                break;
            case 38 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:222: SEMICOLON
                {
                mSEMICOLON(); 

                }
                break;
            case 39 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:232: DOT
                {
                mDOT(); 

                }
                break;
            case 40 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:236: LEFT_PAREN
                {
                mLEFT_PAREN(); 

                }
                break;
            case 41 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:247: RIGHT_PAREN
                {
                mRIGHT_PAREN(); 

                }
                break;
            case 42 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:259: LEFT_BRACKET
                {
                mLEFT_BRACKET(); 

                }
                break;
            case 43 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:272: RIGHT_BRACKET
                {
                mRIGHT_BRACKET(); 

                }
                break;
            case 44 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:286: DIGIT_NULL
                {
                mDIGIT_NULL(); 

                }
                break;
            case 45 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:297: BAR
                {
                mBAR(); 

                }
                break;
            case 46 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:301: ASPA
                {
                mASPA(); 

                }
                break;
            case 47 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:306: WRITEINT
                {
                mWRITEINT(); 

                }
                break;
            case 48 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:315: WRITECHAR
                {
                mWRITECHAR(); 

                }
                break;
            case 49 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:325: WRITEBOOL
                {
                mWRITEBOOL(); 

                }
                break;
            case 50 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:335: WRITESTRING
                {
                mWRITESTRING(); 

                }
                break;
            case 51 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:347: WRITELN
                {
                mWRITELN(); 

                }
                break;
            case 52 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:355: LETTER
                {
                mLETTER(); 

                }
                break;
            case 53 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:362: DIGIT
                {
                mDIGIT(); 

                }
                break;
            case 54 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:368: BOOL
                {
                mBOOL(); 

                }
                break;
            case 55 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:373: NEWLINE
                {
                mNEWLINE(); 

                }
                break;
            case 56 :
                // C:\\Documents and Settings\\sb\\Desktop\\gramaticaMM2.g:1:381: WS
                {
                mWS(); 

                }
                break;

        }

    }


    protected DFA4 dfa4 = new DFA4(this);
    static final String DFA4_eotS =
        "\1\uffff\17\41\4\uffff\1\102\1\104\1\106\14\uffff\1\45\1\107\43"+
        "\uffff\1\113\12\uffff";
    static final String DFA4_eofS =
        "\123\uffff";
    static final String DFA4_minS =
        "\1\11\1\117\1\105\1\114\1\101\2\106\1\110\2\101\1\110\1\122\1\105"+
        "\1\111\1\116\1\117\4\uffff\3\75\14\uffff\1\12\1\11\1\uffff\1\104"+
        "\21\uffff\1\111\17\uffff\1\125\1\124\2\uffff\1\105\1\102\5\uffff";
    static final String DFA4_maxS =
        "\1\174\1\117\1\131\1\116\1\101\1\122\1\116\1\122\1\110\1\117\2"+
        "\122\1\105\1\117\1\122\1\117\4\uffff\1\76\2\75\14\uffff\1\12\1\40"+
        "\1\uffff\1\104\21\uffff\1\111\17\uffff\1\125\1\124\2\uffff\1\105"+
        "\1\123\5\uffff";
    static final String DFA4_acceptS =
        "\20\uffff\1\26\1\27\1\30\1\33\3\uffff\1\44\1\46\1\47\1\50\1\51"+
        "\1\52\1\53\1\54\1\55\1\56\1\64\1\65\2\uffff\1\70\1\uffff\1\2\1\17"+
        "\1\22\1\3\1\10\1\4\1\5\1\42\1\6\1\21\1\7\1\16\1\66\1\11\1\23\1\12"+
        "\1\13\1\uffff\1\14\1\15\1\20\1\31\1\24\1\41\1\25\1\34\1\40\1\36"+
        "\1\37\1\35\1\43\1\45\1\67\2\uffff\1\1\1\32\2\uffff\1\57\1\60\1\61"+
        "\1\62\1\63";
    static final String DFA4_specialS =
        "\123\uffff}>";
    static final String[] DFA4_transitionS = {
            "\1\45\1\44\2\uffff\1\43\22\uffff\1\45\6\uffff\1\40\1\32\1\33"+
            "\1\22\1\21\1\27\1\20\1\31\1\uffff\1\36\11\42\1\26\1\30\1\24"+
            "\1\23\1\25\2\uffff\1\16\1\2\1\10\1\15\1\3\1\11\2\41\1\6\3\41"+
            "\1\1\1\17\1\5\1\13\1\41\1\14\1\41\1\7\1\41\1\4\1\12\3\41\1\34"+
            "\1\uffff\1\35\3\uffff\32\41\1\uffff\1\37",
            "\1\46",
            "\1\47\11\uffff\1\51\11\uffff\1\50",
            "\1\53\1\uffff\1\52",
            "\1\54",
            "\1\55\13\uffff\1\56",
            "\1\57\7\uffff\1\60",
            "\1\61\6\uffff\1\62\2\uffff\1\63",
            "\1\64\6\uffff\1\65",
            "\1\63\15\uffff\1\66",
            "\1\67\11\uffff\1\70",
            "\1\71",
            "\1\72",
            "\1\74\5\uffff\1\73",
            "\1\76\3\uffff\1\75",
            "\1\77",
            "",
            "",
            "",
            "",
            "\1\101\1\100",
            "\1\103",
            "\1\105",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\44",
            "\2\45\2\uffff\1\45\22\uffff\1\45",
            "",
            "\1\110",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\111",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\112",
            "\1\114",
            "",
            "",
            "\1\115",
            "\1\120\1\117\5\uffff\1\116\2\uffff\1\122\6\uffff\1\121",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
    static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
    static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
    static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
    static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
    static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
    static final short[][] DFA4_transition;

    static {
        int numStates = DFA4_transitionS.length;
        DFA4_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
        }
    }

    class DFA4 extends DFA {

        public DFA4(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 4;
            this.eot = DFA4_eot;
            this.eof = DFA4_eof;
            this.min = DFA4_min;
            this.max = DFA4_max;
            this.accept = DFA4_accept;
            this.special = DFA4_special;
            this.transition = DFA4_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( MODULE | BEGIN | END | VAR | OF | IF | THEN | ELSE | CASE | FOR | WHILE | PROCEDURE | RETURN | TO | BY | DO | INTEGER | BOOLEAN | CHAR | ARRAY | NOT | MINUS | PLUS | MULT | DIV | MOD | EQUAL | NEQUAL | GREATER | LOWER | GREATER_EQUAL | LOWER_EQUAL | AND | OR | ASSIGN | COMMA | COLON | SEMICOLON | DOT | LEFT_PAREN | RIGHT_PAREN | LEFT_BRACKET | RIGHT_BRACKET | DIGIT_NULL | BAR | ASPA | WRITEINT | WRITECHAR | WRITEBOOL | WRITESTRING | WRITELN | LETTER | DIGIT | BOOL | NEWLINE | WS );";
        }
    }
 

}